home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_tarfile.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  15.9 KB  |  488 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import sys
  5. import os
  6. import shutil
  7. import tempfile
  8. import unittest
  9. import tarfile
  10. from test import test_support
  11.  
  12. try:
  13.     import gzip
  14.     gzip.GzipFile
  15. except (ImportError, AttributeError):
  16.     gzip = None
  17.  
  18.  
  19. try:
  20.     import bz2
  21. except ImportError:
  22.     bz2 = None
  23.  
  24.  
  25. def path(path):
  26.     return test_support.findfile(path)
  27.  
  28. testtar = path('testtar.tar')
  29. tempdir = os.path.join(tempfile.gettempdir(), 'testtar' + os.extsep + 'dir')
  30. tempname = test_support.TESTFN
  31. membercount = 10
  32.  
  33. def tarname(comp = ''):
  34.     if not comp:
  35.         return testtar
  36.     
  37.     return os.path.join(tempdir, '%s%s%s' % (testtar, os.extsep, comp))
  38.  
  39.  
  40. def dirname():
  41.     if not os.path.exists(tempdir):
  42.         os.mkdir(tempdir)
  43.     
  44.     return tempdir
  45.  
  46.  
  47. def tmpname():
  48.     return tempname
  49.  
  50.  
  51. class BaseTest(unittest.TestCase):
  52.     comp = ''
  53.     mode = 'r'
  54.     sep = ':'
  55.     
  56.     def setUp(self):
  57.         mode = self.mode + self.sep + self.comp
  58.         self.tar = tarfile.open(tarname(self.comp), mode)
  59.  
  60.     
  61.     def tearDown(self):
  62.         self.tar.close()
  63.  
  64.  
  65.  
  66. class ReadTest(BaseTest):
  67.     
  68.     def test(self):
  69.         '''Test member extraction.
  70.         '''
  71.         members = 0
  72.         for tarinfo in self.tar:
  73.             members += 1
  74.             if not tarinfo.isreg():
  75.                 continue
  76.             
  77.             f = self.tar.extractfile(tarinfo)
  78.             self.assert_(len(f.read()) == tarinfo.size, 'size read does not match expected size')
  79.             f.close()
  80.         
  81.         self.assert_(members == membercount, 'could not find all members')
  82.  
  83.     
  84.     def test_sparse(self):
  85.         '''Test sparse member extraction.
  86.         '''
  87.         if self.sep != '|':
  88.             f1 = self.tar.extractfile('S-SPARSE')
  89.             f2 = self.tar.extractfile('S-SPARSE-WITH-NULLS')
  90.             self.assert_(f1.read() == f2.read(), '_FileObject failed on sparse file member')
  91.         
  92.  
  93.     
  94.     def test_readlines(self):
  95.         '''Test readlines() method of _FileObject.
  96.         '''
  97.         if self.sep != '|':
  98.             filename = '0-REGTYPE-TEXT'
  99.             self.tar.extract(filename, dirname())
  100.             lines1 = file(os.path.join(dirname(), filename), 'rU').readlines()
  101.             lines2 = self.tar.extractfile(filename).readlines()
  102.             self.assert_(lines1 == lines2, '_FileObject.readline() does not work correctly')
  103.         
  104.  
  105.     
  106.     def test_seek(self):
  107.         '''Test seek() method of _FileObject, incl. random reading.
  108.         '''
  109.         if self.sep != '|':
  110.             filename = '0-REGTYPE'
  111.             self.tar.extract(filename, dirname())
  112.             data = file(os.path.join(dirname(), filename), 'rb').read()
  113.             tarinfo = self.tar.getmember(filename)
  114.             fobj = self.tar.extractfile(tarinfo)
  115.             text = fobj.read()
  116.             fobj.seek(0)
  117.             self.assert_(0 == fobj.tell(), "seek() to file's start failed")
  118.             fobj.seek(2048, 0)
  119.             self.assert_(2048 == fobj.tell(), 'seek() to absolute position failed')
  120.             fobj.seek(-1024, 1)
  121.             self.assert_(1024 == fobj.tell(), 'seek() to negative relative position failed')
  122.             fobj.seek(1024, 1)
  123.             self.assert_(2048 == fobj.tell(), 'seek() to positive relative position failed')
  124.             s = fobj.read(10)
  125.             self.assert_(s == data[2048:2058], 'read() after seek failed')
  126.             fobj.seek(0, 2)
  127.             self.assert_(tarinfo.size == fobj.tell(), "seek() to file's end failed")
  128.             self.assert_(fobj.read() == '', "read() at file's end did not return empty string")
  129.             fobj.seek(-(tarinfo.size), 2)
  130.             self.assert_(0 == fobj.tell(), "relative seek() to file's start failed")
  131.             fobj.seek(512)
  132.             s1 = fobj.readlines()
  133.             fobj.seek(512)
  134.             s2 = fobj.readlines()
  135.             self.assert_(s1 == s2, 'readlines() after seek failed')
  136.             fobj.close()
  137.         
  138.  
  139.  
  140.  
  141. class ReadStreamTest(ReadTest):
  142.     sep = '|'
  143.     
  144.     def test(self):
  145.         '''Test member extraction, and for StreamError when
  146.            seeking backwards.
  147.         '''
  148.         ReadTest.test(self)
  149.         tarinfo = self.tar.getmembers()[0]
  150.         f = self.tar.extractfile(tarinfo)
  151.         self.assertRaises(tarfile.StreamError, f.read)
  152.  
  153.     
  154.     def test_stream(self):
  155.         '''Compare the normal tar and the stream tar.
  156.         '''
  157.         stream = self.tar
  158.         tar = tarfile.open(tarname(), 'r')
  159.         while None:
  160.             t1 = tar.next()
  161.             t2 = stream.next()
  162.             if t1 is None:
  163.                 break
  164.             
  165.             if t2.islnk() or t2.issym():
  166.                 self.assertRaises(tarfile.StreamError, stream.extractfile, t2)
  167.                 continue
  168.             
  169.             v1 = tar.extractfile(t1)
  170.             v2 = stream.extractfile(t2)
  171.             if v1 is None:
  172.                 continue
  173.             
  174.             self.assert_(v2 is not None, 'stream.extractfile() failed')
  175.             self.assert_(v1.read() == v2.read(), 'stream extraction failed')
  176.         stream.close()
  177.  
  178.  
  179.  
  180. class WriteTest(BaseTest):
  181.     mode = 'w'
  182.     
  183.     def setUp(self):
  184.         mode = self.mode + self.sep + self.comp
  185.         self.src = tarfile.open(tarname(self.comp), 'r')
  186.         self.dstname = tmpname()
  187.         self.dst = tarfile.open(self.dstname, mode)
  188.  
  189.     
  190.     def tearDown(self):
  191.         self.src.close()
  192.         self.dst.close()
  193.  
  194.     
  195.     def test_posix(self):
  196.         self.dst.posix = 1
  197.         self._test()
  198.  
  199.     
  200.     def test_nonposix(self):
  201.         self.dst.posix = 0
  202.         self._test()
  203.  
  204.     
  205.     def test_small(self):
  206.         self.dst.add(os.path.join(os.path.dirname(__file__), 'cfgparser.1'))
  207.         self.dst.close()
  208.         self.assertNotEqual(os.stat(self.dstname).st_size, 0)
  209.  
  210.     
  211.     def _test(self):
  212.         for tarinfo in self.src:
  213.             if not tarinfo.isreg():
  214.                 continue
  215.             
  216.             f = self.src.extractfile(tarinfo)
  217.             if self.dst.posix and len(tarinfo.name) > tarfile.LENGTH_NAME:
  218.                 self.assertRaises(ValueError, self.dst.addfile, tarinfo, f)
  219.                 continue
  220.             self.dst.addfile(tarinfo, f)
  221.         
  222.  
  223.  
  224.  
  225. class WriteSize0Test(BaseTest):
  226.     mode = 'w'
  227.     
  228.     def setUp(self):
  229.         self.tmpdir = dirname()
  230.         self.dstname = tmpname()
  231.         self.dst = tarfile.open(self.dstname, 'w')
  232.  
  233.     
  234.     def tearDown(self):
  235.         self.dst.close()
  236.  
  237.     
  238.     def test_file(self):
  239.         path = os.path.join(self.tmpdir, 'file')
  240.         file(path, 'w')
  241.         tarinfo = self.dst.gettarinfo(path)
  242.         self.assertEqual(tarinfo.size, 0)
  243.         file(path, 'w').write('aaa')
  244.         tarinfo = self.dst.gettarinfo(path)
  245.         self.assertEqual(tarinfo.size, 3)
  246.  
  247.     
  248.     def test_directory(self):
  249.         path = os.path.join(self.tmpdir, 'directory')
  250.         os.mkdir(path)
  251.         tarinfo = self.dst.gettarinfo(path)
  252.         self.assertEqual(tarinfo.size, 0)
  253.  
  254.     
  255.     def test_symlink(self):
  256.         if hasattr(os, 'symlink'):
  257.             path = os.path.join(self.tmpdir, 'symlink')
  258.             os.symlink('link_target', path)
  259.             tarinfo = self.dst.gettarinfo(path)
  260.             self.assertEqual(tarinfo.size, 0)
  261.         
  262.  
  263.  
  264.  
  265. class WriteStreamTest(WriteTest):
  266.     sep = '|'
  267.  
  268.  
  269. class WriteGNULongTest(unittest.TestCase):
  270.     """This testcase checks for correct creation of GNU Longname
  271.        and Longlink extensions.
  272.  
  273.        It creates a tarfile and adds empty members with either
  274.        long names, long linknames or both and compares the size
  275.        of the tarfile with the expected size.
  276.  
  277.        It checks for SF bug #812325 in TarFile._create_gnulong().
  278.  
  279.        While I was writing this testcase, I noticed a second bug
  280.        in the same method:
  281.        Long{names,links} weren't null-terminated which lead to
  282.        bad tarfiles when their length was a multiple of 512. This
  283.        is tested as well.
  284.     """
  285.     
  286.     def setUp(self):
  287.         self.tar = tarfile.open(tmpname(), 'w')
  288.         self.tar.posix = False
  289.  
  290.     
  291.     def tearDown(self):
  292.         self.tar.close()
  293.  
  294.     
  295.     def _length(self, s):
  296.         (blocks, remainder) = divmod(len(s) + 1, 512)
  297.         if remainder:
  298.             blocks += 1
  299.         
  300.         return blocks * 512
  301.  
  302.     
  303.     def _calc_size(self, name, link = None):
  304.         count = 512
  305.         if len(name) > tarfile.LENGTH_NAME:
  306.             count += 512
  307.             count += self._length(name)
  308.         
  309.         if link is not None and len(link) > tarfile.LENGTH_LINK:
  310.             count += 512
  311.             count += self._length(link)
  312.         
  313.         return count
  314.  
  315.     
  316.     def _test(self, name, link = None):
  317.         tarinfo = tarfile.TarInfo(name)
  318.         if link:
  319.             tarinfo.linkname = link
  320.             tarinfo.type = tarfile.LNKTYPE
  321.         
  322.         self.tar.addfile(tarinfo)
  323.         v1 = self._calc_size(name, link)
  324.         v2 = self.tar.offset
  325.         self.assertEqual(v1, v2, 'GNU longname/longlink creation failed')
  326.  
  327.     
  328.     def test_longname_1023(self):
  329.         self._test('longnam/' * 127 + 'longnam')
  330.  
  331.     
  332.     def test_longname_1024(self):
  333.         self._test('longnam/' * 127 + 'longname')
  334.  
  335.     
  336.     def test_longname_1025(self):
  337.         self._test('longnam/' * 127 + 'longname_')
  338.  
  339.     
  340.     def test_longlink_1023(self):
  341.         self._test('name', 'longlnk/' * 127 + 'longlnk')
  342.  
  343.     
  344.     def test_longlink_1024(self):
  345.         self._test('name', 'longlnk/' * 127 + 'longlink')
  346.  
  347.     
  348.     def test_longlink_1025(self):
  349.         self._test('name', 'longlnk/' * 127 + 'longlink_')
  350.  
  351.     
  352.     def test_longnamelink_1023(self):
  353.         self._test('longnam/' * 127 + 'longnam', 'longlnk/' * 127 + 'longlnk')
  354.  
  355.     
  356.     def test_longnamelink_1024(self):
  357.         self._test('longnam/' * 127 + 'longname', 'longlnk/' * 127 + 'longlink')
  358.  
  359.     
  360.     def test_longnamelink_1025(self):
  361.         self._test('longnam/' * 127 + 'longname_', 'longlnk/' * 127 + 'longlink_')
  362.  
  363.  
  364.  
  365. class ExtractHardlinkTest(BaseTest):
  366.     
  367.     def test_hardlink(self):
  368.         '''Test hardlink extraction (bug #857297)
  369.         '''
  370.         self.tar.errorlevel = 1
  371.         self.tar.extract('0-REGTYPE', dirname())
  372.         
  373.         try:
  374.             self.tar.extract('1-LNKTYPE', dirname())
  375.         except EnvironmentError:
  376.             e = None
  377.             import errno
  378.             if e.errno == errno.ENOENT:
  379.                 self.fail('hardlink not extracted properly')
  380.             
  381.         except:
  382.             e.errno == errno.ENOENT
  383.  
  384.  
  385.  
  386.  
  387. class ReadTestGzip(ReadTest):
  388.     comp = 'gz'
  389.  
  390.  
  391. class ReadStreamTestGzip(ReadStreamTest):
  392.     comp = 'gz'
  393.  
  394.  
  395. class WriteTestGzip(WriteTest):
  396.     comp = 'gz'
  397.  
  398.  
  399. class WriteStreamTestGzip(WriteStreamTest):
  400.     comp = 'gz'
  401.  
  402.  
  403. class FileModeTest(unittest.TestCase):
  404.     
  405.     def test_modes(self):
  406.         self.assertEqual(tarfile.filemode(493), '-rwxr-xr-x')
  407.         self.assertEqual(tarfile.filemode(3657), '---s--s--t')
  408.  
  409.  
  410. if bz2:
  411.     
  412.     class ReadTestBzip2(ReadTestGzip):
  413.         comp = 'bz2'
  414.  
  415.     
  416.     class ReadStreamTestBzip2(ReadStreamTestGzip):
  417.         comp = 'bz2'
  418.  
  419.     
  420.     class WriteTestBzip2(WriteTest):
  421.         comp = 'bz2'
  422.  
  423.     
  424.     class WriteStreamTestBzip2(WriteStreamTestGzip):
  425.         comp = 'bz2'
  426.  
  427.  
  428. if not gzip:
  429.     del ReadTestGzip
  430.     del ReadStreamTestGzip
  431.     del WriteTestGzip
  432.     del WriteStreamTestGzip
  433.  
  434.  
  435. def test_main():
  436.     if gzip:
  437.         gzip.open(tarname('gz'), 'wb').write(file(tarname(), 'rb').read())
  438.     
  439.     if bz2:
  440.         bz2.BZ2File(tarname('bz2'), 'wb').write(file(tarname(), 'rb').read())
  441.     
  442.     tests = [
  443.         FileModeTest,
  444.         ReadTest,
  445.         ReadStreamTest,
  446.         WriteTest,
  447.         WriteSize0Test,
  448.         WriteStreamTest,
  449.         WriteGNULongTest]
  450.     if hasattr(os, 'link'):
  451.         tests.append(ExtractHardlinkTest)
  452.     
  453.     if gzip:
  454.         tests.extend([
  455.             ReadTestGzip,
  456.             ReadStreamTestGzip,
  457.             WriteTestGzip,
  458.             WriteStreamTestGzip])
  459.     
  460.     if bz2:
  461.         tests.extend([
  462.             ReadTestBzip2,
  463.             ReadStreamTestBzip2,
  464.             WriteTestBzip2,
  465.             WriteStreamTestBzip2])
  466.     
  467.     
  468.     try:
  469.         test_support.run_unittest(*tests)
  470.     finally:
  471.         if gzip:
  472.             os.remove(tarname('gz'))
  473.         
  474.         if bz2:
  475.             os.remove(tarname('bz2'))
  476.         
  477.         if os.path.exists(dirname()):
  478.             shutil.rmtree(dirname())
  479.         
  480.         if os.path.exists(tmpname()):
  481.             os.remove(tmpname())
  482.         
  483.  
  484.  
  485. if __name__ == '__main__':
  486.     test_main()
  487.  
  488.